/**
 * 工具函数库
 */

/**
 * 格式化日期
 * @param {Date|string|number} date 日期
 * @param {string} format 格式化字符串
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!date) return ''
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return ''
  
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hour = String(d.getHours()).padStart(2, '0')
  const minute = String(d.getMinutes()).padStart(2, '0')
  const second = String(d.getSeconds()).padStart(2, '0')
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hour)
    .replace('mm', minute)
    .replace('ss', second)
}

/**
 * 格式化相对时间
 * @param {Date|string|number} date 日期
 * @returns {string} 相对时间字符串
 */
export function formatRelativeTime(date) {
  if (!date) return ''
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return ''
  
  const now = new Date()
  const diff = now.getTime() - d.getTime()
  const seconds = Math.floor(diff / 1000)
  const minutes = Math.floor(seconds / 60)
  const hours = Math.floor(minutes / 60)
  const days = Math.floor(hours / 24)
  
  if (seconds < 60) {
    return '刚刚'
  } else if (minutes < 60) {
    return `${minutes}分钟前`
  } else if (hours < 24) {
    return `${hours}小时前`
  } else if (days < 7) {
    return `${days}天前`
  } else {
    return formatDate(date, 'MM-DD')
  }
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @returns {string} 格式化后的文件大小
 */
export function formatFileSize(bytes) {
  if (!bytes || bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 格式化数字
 * @param {number} num 数字
 * @returns {string} 格式化后的数字字符串
 */
export function formatNumber(num) {
  if (!num && num !== 0) return '0'
  
  if (num < 1000) {
    return num.toString()
  } else if (num < 10000) {
    return (num / 1000).toFixed(1) + 'k'
  } else if (num < 100000000) {
    return (num / 10000).toFixed(1) + 'w'
  } else {
    return (num / 100000000).toFixed(1) + '亿'
  }
}

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {number} wait 等待时间
 * @param {boolean} immediate 是否立即执行
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait, immediate = false) {
  let timeout
  
  return function executedFunction(...args) {
    const later = () => {
      timeout = null
      if (!immediate) func.apply(this, args)
    }
    
    const callNow = immediate && !timeout
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
    
    if (callNow) func.apply(this, args)
  }
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {number} limit 时间间隔
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle
  
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}

/**
 * 深拷贝
 * @param {any} obj 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime())
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item))
  }
  
  if (typeof obj === 'object') {
    const clonedObj = {}
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key])
      }
    }
    return clonedObj
  }
}

/**
 * 生成唯一ID
 * @param {number} length ID长度
 * @returns {string} 唯一ID
 */
export function generateId(length = 8) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  let result = ''
  
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length))
  }
  
  return result
}

/**
 * 验证手机号
 * @param {string} phone 手机号
 * @returns {boolean} 是否有效
 */
export function validatePhone(phone) {
  const phoneRegex = /^1[3-9]\d{9}$/
  return phoneRegex.test(phone)
}

/**
 * 验证邮箱
 * @param {string} email 邮箱
 * @returns {boolean} 是否有效
 */
export function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

/**
 * 验证身份证号
 * @param {string} idCard 身份证号
 * @returns {boolean} 是否有效
 */
export function validateIdCard(idCard) {
  const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
  return idCardRegex.test(idCard)
}

/**
 * 获取URL参数
 * @param {string} name 参数名
 * @param {string} url URL字符串
 * @returns {string|null} 参数值
 */
export function getUrlParam(name, url = window.location.href) {
  const regex = new RegExp('[?&]' + name + '=([^&#]*)', 'i')
  const match = regex.exec(url)
  return match ? decodeURIComponent(match[1]) : null
}

/**
 * 设置URL参数
 * @param {string} name 参数名
 * @param {string} value 参数值
 * @param {string} url URL字符串
 * @returns {string} 新的URL字符串
 */
export function setUrlParam(name, value, url = window.location.href) {
  const regex = new RegExp('([?&])' + name + '=.*?(&|$)', 'i')
  const separator = url.indexOf('?') !== -1 ? '&' : '?'
  
  if (url.match(regex)) {
    return url.replace(regex, '$1' + name + '=' + encodeURIComponent(value) + '$2')
  } else {
    return url + separator + name + '=' + encodeURIComponent(value)
  }
}

/**
 * 本地存储封装
 */
export const storage = {
  /**
   * 设置存储
   * @param {string} key 键
   * @param {any} value 值
   * @param {number} expire 过期时间（毫秒）
   */
  set(key, value, expire = null) {
    const data = {
      value,
      expire: expire ? Date.now() + expire : null
    }
    localStorage.setItem(key, JSON.stringify(data))
  },
  
  /**
   * 获取存储
   * @param {string} key 键
   * @returns {any} 值
   */
  get(key) {
    try {
      const item = localStorage.getItem(key)
      if (!item) return null
      
      const data = JSON.parse(item)
      
      // 检查是否过期
      if (data.expire && Date.now() > data.expire) {
        localStorage.removeItem(key)
        return null
      }
      
      return data.value
    } catch (error) {
      console.error('Storage get error:', error)
      return null
    }
  },
  
  /**
   * 删除存储
   * @param {string} key 键
   */
  remove(key) {
    localStorage.removeItem(key)
  },
  
  /**
   * 清空存储
   */
  clear() {
    localStorage.clear()
  }
}

/**
 * 设备检测
 */
export const device = {
  /**
   * 是否为移动设备
   * @returns {boolean}
   */
  isMobile() {
    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
  },
  
  /**
   * 是否为iOS设备
   * @returns {boolean}
   */
  isIOS() {
    return /iPad|iPhone|iPod/.test(navigator.userAgent)
  },
  
  /**
   * 是否为Android设备
   * @returns {boolean}
   */
  isAndroid() {
    return /Android/.test(navigator.userAgent)
  },
  
  /**
   * 是否为微信浏览器
   * @returns {boolean}
   */
  isWeChat() {
    return /MicroMessenger/i.test(navigator.userAgent)
  },
  
  /**
   * 获取设备像素比
   * @returns {number}
   */
  getPixelRatio() {
    return window.devicePixelRatio || 1
  },
  
  /**
   * 获取屏幕尺寸
   * @returns {object}
   */
  getScreenSize() {
    return {
      width: window.screen.width,
      height: window.screen.height
    }
  },
  
  /**
   * 获取视口尺寸
   * @returns {object}
   */
  getViewportSize() {
    return {
      width: window.innerWidth || document.documentElement.clientWidth,
      height: window.innerHeight || document.documentElement.clientHeight
    }
  }
}

/**
 * 颜色工具
 */
export const color = {
  /**
   * 十六进制转RGB
   * @param {string} hex 十六进制颜色
   * @returns {object|null} RGB对象
   */
  hexToRgb(hex) {
    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
    return result ? {
      r: parseInt(result[1], 16),
      g: parseInt(result[2], 16),
      b: parseInt(result[3], 16)
    } : null
  },
  
  /**
   * RGB转十六进制
   * @param {number} r 红色值
   * @param {number} g 绿色值
   * @param {number} b 蓝色值
   * @returns {string} 十六进制颜色
   */
  rgbToHex(r, g, b) {
    return '#' + [r, g, b].map(x => {
      const hex = x.toString(16)
      return hex.length === 1 ? '0' + hex : hex
    }).join('')
  },
  
  /**
   * 生成随机颜色
   * @returns {string} 十六进制颜色
   */
  random() {
    return '#' + Math.floor(Math.random() * 16777215).toString(16)
  }
}

/**
 * 数组工具
 */
export const array = {
  /**
   * 数组去重
   * @param {Array} arr 数组
   * @param {string} key 去重的键（对象数组）
   * @returns {Array} 去重后的数组
   */
  unique(arr, key = null) {
    if (!Array.isArray(arr)) return []
    
    if (key) {
      const seen = new Set()
      return arr.filter(item => {
        const value = item[key]
        if (seen.has(value)) {
          return false
        }
        seen.add(value)
        return true
      })
    }
    
    return [...new Set(arr)]
  },
  
  /**
   * 数组分组
   * @param {Array} arr 数组
   * @param {string|Function} key 分组的键或函数
   * @returns {object} 分组后的对象
   */
  groupBy(arr, key) {
    if (!Array.isArray(arr)) return {}
    
    return arr.reduce((groups, item) => {
      const group = typeof key === 'function' ? key(item) : item[key]
      groups[group] = groups[group] || []
      groups[group].push(item)
      return groups
    }, {})
  },
  
  /**
   * 数组排序
   * @param {Array} arr 数组
   * @param {string} key 排序的键
   * @param {string} order 排序方式（asc/desc）
   * @returns {Array} 排序后的数组
   */
  sortBy(arr, key, order = 'asc') {
    if (!Array.isArray(arr)) return []
    
    return [...arr].sort((a, b) => {
      const aVal = a[key]
      const bVal = b[key]
      
      if (aVal < bVal) {
        return order === 'asc' ? -1 : 1
      }
      if (aVal > bVal) {
        return order === 'asc' ? 1 : -1
      }
      return 0
    })
  },
  
  /**
   * 数组分页
   * @param {Array} arr 数组
   * @param {number} page 页码
   * @param {number} size 每页大小
   * @returns {Array} 分页后的数组
   */
  paginate(arr, page, size) {
    if (!Array.isArray(arr)) return []
    
    const start = (page - 1) * size
    const end = start + size
    return arr.slice(start, end)
  }
}

/**
 * 字符串工具
 */
export const string = {
  /**
   * 首字母大写
   * @param {string} str 字符串
   * @returns {string} 处理后的字符串
   */
  capitalize(str) {
    if (!str) return ''
    return str.charAt(0).toUpperCase() + str.slice(1)
  },
  
  /**
   * 驼峰转下划线
   * @param {string} str 字符串
   * @returns {string} 处理后的字符串
   */
  camelToSnake(str) {
    if (!str) return ''
    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`)
  },
  
  /**
   * 下划线转驼峰
   * @param {string} str 字符串
   * @returns {string} 处理后的字符串
   */
  snakeToCamel(str) {
    if (!str) return ''
    return str.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase())
  },
  
  /**
   * 截断字符串
   * @param {string} str 字符串
   * @param {number} length 长度
   * @param {string} suffix 后缀
   * @returns {string} 处理后的字符串
   */
  truncate(str, length, suffix = '...') {
    if (!str) return ''
    if (str.length <= length) return str
    return str.slice(0, length) + suffix
  },
  
  /**
   * 移除HTML标签
   * @param {string} str 字符串
   * @returns {string} 处理后的字符串
   */
  stripHtml(str) {
    if (!str) return ''
    return str.replace(/<[^>]*>/g, '')
  }
}